home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / FGDEMO40.ZIP / SOURCE.COM / FUNDMTLS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-12  |  13.8 KB  |  631 lines
  1. /**********************************************************************\
  2. *                                                                      *
  3. *  fundmtls.c -- graphics fundamentals: points, lines, rects, etc.     *
  4. *                                                                      *
  5. \**********************************************************************/
  6.  
  7. #include "defs.h"
  8.  
  9. /**********************************************************************\
  10. *                                                                      *
  11. *  do_boxes -- draw a bunch of hollow rectangles                       *
  12. *                                                                      *
  13. \**********************************************************************/
  14.  
  15. do_boxes()
  16. {
  17.    register int i,j;
  18.    int x1,x2,y1,y2;
  19.    int color;
  20.  
  21.    fg_mousevis(OFF);
  22.  
  23.    /* set the clip region */
  24.  
  25.    fg_setclip(5,xlimit-5,menu_bottom,ylimit-4);
  26.  
  27.    /* clear the bottom of the screen */
  28.  
  29.    fg_setcolor(14);
  30.    fg_rect(5,xlimit-5,menu_bottom,ylimit-4);
  31.  
  32.    /* draw some boxes */
  33.  
  34.    for (j = 20; j<= 420; j+=200)
  35.    {
  36.       x1 = j;
  37.       x2 = x1+200;
  38.       y1 = 50;
  39.       y2 = 170;
  40.       if (x1 == 220)
  41.          fg_boxdepth(1,4);
  42.       else
  43.          fg_boxdepth(3,2);
  44.       color = 1;
  45.       for (i = 0; i < 15; i++)
  46.       {
  47.          fg_setcolor(color);
  48.          fg_box(x1,x2,y1,y2);
  49.          x1 += 3;
  50.          x2 -= 8;
  51.          y2 -= 2;
  52.          y1 += 6;
  53.          color = 10 - color;
  54.       }
  55.    }
  56.    for (j = 20; j<= 420; j+=200)
  57.    {
  58.       x1 = j;
  59.       x2 = x1+200;
  60.       y1 = 170;
  61.       y2 = 290;
  62.       if (x1 == 220)
  63.          fg_boxdepth(3,2);
  64.       else
  65.          fg_boxdepth(1,4);
  66.       color = 1;
  67.       for (i = 0; i < 15; i++)
  68.       {
  69.          fg_setcolor(color);
  70.          fg_box(x1,x2,y1,y2);
  71.          x1 += 3;
  72.          x2 -= 8;
  73.          y2 -= 2;
  74.          y1 += 6;
  75.          color = 10 - color;
  76.       }
  77.    }
  78.  
  79.    /* restore box size to the default */
  80.  
  81.    fg_boxdepth(1,1);
  82.  
  83.    /* wait for a keystroke or mouse button */
  84.  
  85.    fg_mousevis(ON);
  86.    wait_for_keystroke();
  87.  
  88.    /* restore the screen and return to the menu */
  89.  
  90.    fg_mousevis(OFF);
  91.    fg_restore(0,xlimit,menu_bottom,ylimit);
  92.  
  93.    fg_mousevis(ON);
  94.    redraw = TRUE;
  95.  
  96.    return(OK);
  97. }
  98.  
  99. /**********************************************************************\
  100. *                                                                      *
  101. *  do_circles -- draw a bunch of circles                               *
  102. *                                                                      *
  103. \**********************************************************************/
  104.  
  105. do_circles()
  106. {
  107.    register int i;
  108.    int x1,x2,y1;
  109.  
  110.    fg_mousevis(OFF);
  111.    fg_setcolor(1);
  112.    fg_rect(5,xlimit-5,menu_bottom,ylimit-4);
  113.  
  114.    /* move to the center of the screen */
  115.  
  116.    x1 = xlimit / 2;
  117.    y1 = (ylimit + menu_bottom) / 2;
  118.    fg_move(x1,y1);
  119.  
  120.    /* draw concentric circles */
  121.  
  122.    x2 = 4;
  123.    fg_setcolor(15);
  124.    for (i = 0; i < 25; i++)
  125.    {
  126.       fg_circle(x2);
  127.       x2 += 8;
  128.    }
  129.  
  130.    /* wait for a keystroke */
  131.  
  132.    fg_mousevis(ON);
  133.    wait_for_keystroke();
  134.  
  135.    /* restore the screen and return to the menu */
  136.  
  137.    fg_mousevis(OFF);
  138.    fg_restore(0,xlimit,menu_bottom,ylimit);
  139.  
  140.    fg_mousevis(ON);
  141.    redraw = TRUE;
  142.  
  143.    return(OK);
  144. }
  145.  
  146. /**********************************************************************\
  147. *                                                                      *
  148. *  do_ellipses -- draw a bunch of elipses                              *
  149. *                                                                      *
  150. \**********************************************************************/
  151.  
  152. do_ellipses()
  153. {
  154.    register int i;
  155.    int x1,x2,x3,y1;
  156.  
  157.    /* clear the screen */
  158.  
  159.    fg_mousevis(OFF);
  160.    fg_setcolor(9);
  161.    fg_rect(5,xlimit-5,menu_bottom,ylimit-4);
  162.  
  163.    /* move to the center of the screen */
  164.  
  165.    x1 = xlimit / 2;
  166.    y1 = (ylimit + menu_bottom) / 2;
  167.    fg_move(x1,y1);
  168.  
  169.    /* draw concentric ellipses */
  170.  
  171.    x2 = 4;
  172.    x3 = 1;
  173.    fg_setcolor(0);
  174.    for (i = 0; i < 80; i++)
  175.    {
  176.       fg_ellipse(x2,x3);
  177.       x2 += 3;
  178.       x3++;
  179.    }
  180.  
  181.    /* wait for a keystroke or mouse button */
  182.  
  183.    fg_mousevis(ON);
  184.    wait_for_keystroke();
  185.  
  186.    /* restore the screen and return to the menu */
  187.  
  188.    fg_mousevis(OFF);
  189.    fg_restore(0,xlimit,menu_bottom,ylimit);
  190.  
  191.    fg_mousevis(ON);
  192.    redraw = TRUE;
  193.  
  194.    return(OK);
  195. }
  196.  
  197. /**********************************************************************\
  198. *                                                                      *
  199. *  do_lines -- draw lines to create a plaid pattern                    *
  200. *                                                                      *
  201. \**********************************************************************/
  202.  
  203. do_lines()
  204. {
  205.    register int i,j;
  206.    int x1,x2,y1,y2;
  207.    int xinc;
  208.  
  209.    static int lcolor[] = {2,1,9,11,11,9,1,2};
  210.  
  211.    /* clear bottom part of screen */
  212.  
  213.    fg_mousevis(OFF);
  214.    fg_setclip(5,xlimit-5,menu_bottom,ylimit-4);
  215.  
  216.    fg_setcolor(15);
  217.    fg_rect(5,xlimit-5,menu_bottom,ylimit-4);
  218.  
  219.    /* draw horizontal lines */
  220.  
  221.    fg_setcolor(0);
  222.    for (i = menu_bottom; i < ylimit; i+=40)
  223.    {
  224.       for (j = 0; j < 8; j++)
  225.       {
  226.          fg_setcolor(lcolor[j]);
  227.  
  228.          y1 = i + 3*j;
  229.          fg_move(0,y1);
  230.          fg_draw(xlimit,y1);
  231.  
  232.       }
  233.    }
  234.  
  235.    /* draw vertical lines */
  236.  
  237.    y1 = menu_bottom;
  238.    y2 = ylimit;
  239.    for (i = 0; i < 640; i+=60)
  240.    {
  241.       for (j = 0; j < 8; j++)
  242.       {
  243.          fg_setcolor(lcolor[j]);
  244.  
  245.          x1 = i + 3*j;
  246.          fg_move(x1,y1);
  247.          fg_draw(x1,y2);
  248.       }
  249.    }
  250.  
  251.    /* draw red diagonal lines */
  252.  
  253.    y1 = menu_bottom;
  254.    y2 = ylimit;
  255.    xinc = ylimit - menu_bottom;
  256.    fg_setcolor(12);
  257.    for (x1 = -640; x1 < 640; x1+=60)
  258.    {
  259.       x2 = x1 + xinc;
  260.       fg_move(x1,y1);
  261.       fg_draw(x2,y2);
  262.    }
  263.  
  264.    y1 = menu_bottom;
  265.    y2 = ylimit;
  266.    xinc = ylimit - menu_bottom;
  267.  
  268.    /* draw red diagonal lines */
  269.  
  270.    fg_setcolor(12);
  271.    for (x1 = 0; x1 < 1280; x1+=60)
  272.    {
  273.       x2 = x1 - xinc;
  274.       fg_move(x1,y1);
  275.       fg_draw(x2,y2);
  276.    }
  277.  
  278.    /* restore the clipping limits */
  279.  
  280.    fg_setclip(0,fg_getmaxx(),0,fg_getmaxy());
  281.  
  282.    /* wait for a keystroke or mouse button */
  283.  
  284.    fg_mousevis(ON);
  285.    wait_for_keystroke();
  286.  
  287.    /* restore the screen and return to the menu */
  288.  
  289.    fg_mousevis(OFF);
  290.    fg_restore(0,xlimit,menu_bottom,ylimit);
  291.  
  292.    fg_mousevis(ON);
  293.    redraw = TRUE;
  294.  
  295.    return(OK);
  296. }
  297.  
  298. /**********************************************************************\
  299. *                                                                      *
  300. *  do_paint -- draw a quartered circle, then paint around it           *
  301. *                                                                      *
  302. \**********************************************************************/
  303.  
  304. do_paint()
  305. {
  306.    int x1,x2,y1,y2;
  307.  
  308.    /* restor the screen */
  309.  
  310.    fg_mousevis(OFF);
  311.    fg_restore(0,xlimit,menu_bottom,ylimit);
  312.  
  313.    /* draw a rectangle */
  314.  
  315.    y1 = menu_bottom + 20;
  316.    y2 = ylimit - 20;
  317.    x1 = 40;
  318.    x2 = xlimit - 40;
  319.  
  320.    fg_setcolor(11);
  321.    fg_rect(x1,x2,y1,y2);
  322.  
  323.    /* outline the rectangle */
  324.  
  325.    fg_setcolor(0);
  326.    fg_box(x1,x2,y1,y2);
  327.  
  328.    y1 = (ylimit + menu_bottom) / 2;
  329.    x1 = xlimit / 2;
  330.    fg_move(x1,y1);
  331.  
  332.    /* draw the circle */
  333.  
  334.    fg_setcolor(0);
  335.    fg_circle(80);
  336.  
  337.    /* draw cross bars in the circle */
  338.  
  339.    y2 = 80;
  340.    fg_move(x1,y1-y2);
  341.    fg_draw(x1,y1+y2);
  342.  
  343.    x2 = 100;
  344.    fg_move(x1-x2,y1);
  345.    fg_draw(x1+x2,y1);
  346.  
  347.    /* paint each quarter of the circle */
  348.  
  349.    fg_setcolor(1);
  350.    fg_paint(x1-6,y1-6);
  351.  
  352.    fg_setcolor(2);
  353.    fg_paint(x1+6,y1+6);
  354.  
  355.    fg_setcolor(3);
  356.    fg_paint(x1+6,y1-6);
  357.  
  358.    fg_setcolor(4);
  359.    fg_paint(x1-6,y1+6);
  360.  
  361.    /* paint the box */
  362.  
  363.    x1 = 41;
  364.    y1 = menu_bottom + 20 + 1;
  365.  
  366.    fg_setcolor(14);
  367.    fg_paint(x1,y1);
  368.  
  369.    /* wait for a keystroke or a mouse button */
  370.  
  371.    fg_mousevis(ON);
  372.    wait_for_keystroke();
  373.  
  374.    /* restore the screen and return to the menu */
  375.  
  376.    fg_mousevis(OFF);
  377.    fg_restore(0,xlimit,menu_bottom,ylimit);
  378.  
  379.    fg_mousevis(ON);
  380.    redraw = TRUE;
  381.  
  382.    return(OK);
  383. }
  384.  
  385. /**********************************************************************\
  386. *                                                                      *
  387. *  do_points -- draw a nice pattern of points                          *
  388. *                                                                      *
  389. \**********************************************************************/
  390.  
  391. do_points()
  392. {
  393.    register int i,j;
  394.    int yinc;
  395.  
  396.    /* clear the bottom part of the screen */
  397.  
  398.    fg_mousevis(OFF);
  399.    fg_setclip(5,xlimit-5,menu_bottom,ylimit-4);
  400.  
  401.    fg_setcolor(1);
  402.    fg_rect(5,xlimit-5,menu_bottom,ylimit-4);
  403.  
  404.    yinc = 8;
  405.  
  406.    /* draw the patterns of points */
  407.  
  408.    fg_setcolor(15);
  409.    for (i = 7; i < xlimit; i+=20)
  410.    {
  411.       for (j = menu_bottom+2; j < ylimit; j+=yinc)
  412.          fg_point(i,j);
  413.    }
  414.  
  415.    for (i = 17; i < xlimit; i+=20)
  416.    {
  417.       for (j = menu_bottom+yinc/2+2; j < ylimit; j+=yinc)
  418.          fg_point(i,j);
  419.    }
  420.  
  421.    /* restore the clipping limits */
  422.  
  423.    fg_setclip(0,fg_getmaxx(),0,fg_getmaxy());
  424.  
  425.    /* wait for a keystroke or mouse button */
  426.  
  427.    fg_mousevis(ON);
  428.    wait_for_keystroke();
  429.  
  430.    /* restore the screen and return to the menu */
  431.  
  432.    fg_mousevis(OFF);
  433.    fg_restore(0,xlimit,menu_bottom,ylimit);
  434.  
  435.    fg_mousevis(ON);
  436.    redraw = TRUE;
  437.  
  438.    return(OK);
  439. }
  440.  
  441. /**********************************************************************\
  442. *                                                                      *
  443. *  do_polygons -- draw a polygon pattern with a 3-D effect             *
  444. *                                                                      *
  445. \**********************************************************************/
  446.  
  447. do_polygons()
  448. {
  449.    register int i,j;
  450.  
  451.    int vertices = 4;
  452.  
  453.    static int xy_dkblue[]  = {0,16, 24,0, 24,40, 0,56};
  454.    static int xy_ltblue[]  = {24,0, 72,0, 72,40, 24,40};
  455.    static int xy_magenta[] = {0,56, 24,40, 72,40, 48,56};
  456.  
  457.    int work_array[120];
  458.  
  459.    fg_mousevis(OFF);
  460.  
  461.    /* set the clipping limits */
  462.  
  463.    fg_setclip(5,xlimit-5,menu_bottom,ylimit-4);
  464.  
  465.    for (j = 0; j < 10; j++)
  466.    {
  467.       for (i = 0; i < 12; i++)
  468.       {
  469.          fg_polyoff(i*72-j*24,i*-16+j*56);
  470.          fg_setcolor(1);
  471.          fg_polyfill(xy_dkblue,work_array,vertices);
  472.          fg_setcolor(9);
  473.          fg_polyfill(xy_ltblue,work_array,vertices);
  474.          fg_setcolor(10);
  475.          fg_polyfill(xy_magenta,work_array,vertices);
  476.       }
  477.    }
  478.  
  479.    /* restore the clipping limits */
  480.  
  481.    fg_setclip(0,fg_getmaxx(),0,fg_getmaxy());
  482.  
  483.    /* wait for a keystroke or mouse button */
  484.  
  485.    fg_mousevis(ON);
  486.    wait_for_keystroke();
  487.  
  488.    /* restore the screen and return to the menu */
  489.  
  490.    fg_mousevis(OFF);
  491.    fg_restore(0,xlimit,menu_bottom,ylimit);
  492.  
  493.    fg_mousevis(ON);
  494.    redraw = TRUE;
  495.  
  496.    return(OK);
  497. }
  498.  
  499. /**********************************************************************\
  500. *                                                                      *
  501. *  do_rects -- draw a pattern of solid rectangles                      *
  502. *                                                                      *
  503. \**********************************************************************/
  504.  
  505. do_rects()
  506. {
  507.    register int i,j;
  508.    int x0,x1,x2,y1,y2;
  509.    int xinc,yinc;
  510.    int color;
  511.  
  512.    x0 = 5;
  513.    x1 = x0;
  514.    xinc = (xlimit - x0 - 1) / 10;
  515.    x2 = x1 + xinc;
  516.  
  517.    yinc = (ylimit - menu_bottom) / 10;
  518.    y1 = menu_bottom;
  519.    y2 = y1 + yinc;
  520.  
  521.    color = 0;
  522.  
  523.    /* draw 100 solid rectangles */
  524.  
  525.    fg_mousevis(OFF);
  526.    for (i = 0; i < 10; i++)
  527.    {
  528.       for (j = 0; j < 10; j++)
  529.       {
  530.          fg_setcolor(color);
  531.          fg_rect(x1,x2,y1,y2);
  532.  
  533.          color++;
  534.          if (color > 14) color = 0;
  535.  
  536.          x1 = x2;
  537.          x2 = x1 + xinc;
  538.       }
  539.       x1 = x0;
  540.       x2 = x1 + xinc;
  541.  
  542.       y1 = y2;
  543.       y2 = y1 + yinc;
  544.       if (y2 > 345) y2 = 345;
  545.    }
  546.  
  547.    /* wait for a keystroke or mouse button */
  548.  
  549.    fg_mousevis(ON);
  550.    wait_for_keystroke();
  551.  
  552.    /* restore the screen and return to the menu */
  553.  
  554.    fg_mousevis(OFF);
  555.    fg_restore(0,xlimit,menu_bottom,ylimit);
  556.  
  557.    fg_mousevis(ON);
  558.    redraw = TRUE;
  559.  
  560.    return(OK);
  561. }
  562.  
  563. /**********************************************************************\
  564. *                                                                      *
  565. *  do_text -- demonstrate ROM text                                     *
  566. *                                                                      *
  567. \**********************************************************************/
  568.  
  569. do_text()
  570. {
  571.    register int i;
  572.    register int row;
  573.    int x1,x2,y1,y2;
  574.  
  575.    static char *string[] = {
  576.    "Fastgraph allows you to display",
  577.    "ROM text, a stroke character font,",
  578.    "or define your own bitmapped font.",
  579.    "This message is displayed using",
  580.    "ROM text. The menus use bitmapped",
  581.    "characters."
  582.    };
  583.  
  584.    fg_mousevis(OFF);
  585.  
  586.    fg_restore(0,xlimit,menu_bottom,ylimit);
  587.  
  588.    /* convert rows and columns to x's and y's */
  589.  
  590.    x1 = fg_xconvert(20);
  591.    x2 = fg_xconvert(60);
  592.  
  593.    y1 = fg_yconvert(5);
  594.    y2 = fg_yconvert(13);
  595.  
  596.    /* draw a small rectangle */
  597.  
  598.    fg_setcolor(1);
  599.    fg_rect(x1,x2,y1,y2);
  600.  
  601.    /* draw a white boarder around the box */
  602.  
  603.    fg_setcolor(15);
  604.    fg_box(x1+1,x2-1,y1+1,y2-1);
  605.  
  606.    /* put ROM text in the box */
  607.  
  608.    row = 6;
  609.    for (i = 0; i < 6; i++)
  610.    {
  611.       fg_locate(row,23);
  612.       fg_text(string[i],strlen(string[i]));
  613.       row++;
  614.    }
  615.  
  616.    /* wait for a keystroke or mouse button */
  617.  
  618.    fg_mousevis(ON);
  619.    wait_for_keystroke();
  620.  
  621.    /* restore the screen and return to the menu */
  622.  
  623.    fg_mousevis(OFF);
  624.    fg_restore(0,xlimit,menu_bottom,ylimit);
  625.  
  626.    fg_mousevis(ON);
  627.    redraw = TRUE;
  628.  
  629.    return(OK);
  630. }
  631.